feat: Add the override marker to the models and mark evaluations - #526

Adds ldclient.impl.integrations.files.filedata, the file reading, parsing,
and merging logic that the file-based override source is built on. A
document that starts with an opening brace is parsed as JSON and any other
document as YAML. Definitions are decoded into the flag and segment models
while the file is read, so an invalid definition fails that load. Files are
merged in the configured order with a duplicate keys handling of fail or
ignore, and the result records how many entries each file supplied.

The Reloader owns the reload cycle: it serializes reloads, debounces change
signals with a settle window, keeps the last good data by not applying a
failed load, retries a failed load after a bounded delay, reports an identical
failure once, and skips an application whose file contents did not change. It
can treat a configured file that does not exist as a file with no content.
The Poller detects changes by comparing modification time and size on an
interval, including files that appear or disappear. The Watcher uses the
watchdog package, watches the directory of each file so an absent file is
picked up when it appears, matches the destination of a move so a file
written by rename is detected, retries a directory that does not exist yet,
and reacts only to notifications that can change a file's content or
presence.

The existing file data sources are not changed and keep their current
behavior. A new test module pins that behavior: the flagValues expansion and
its evaluation reason, the version fallback, the failure messages, the FDv2
status and error kinds, and the polling and watching rules.

…st watch

The reloader treats an exception from apply like a load failure: it is reported, retried, and the result is not remembered as the last good one. An exception from the error callback is logged and does not stop the retry. The watcher retries when the observer cannot start, watches a directory again after it is deleted and recreated, and closes without error when the observer never started.

A plain rewrite is not atomic: the truncation and the write are separate steps, and a poll that lands between them legitimately reports an extra change. The poller promises generous detection, not one callback per logical change; the reloader coalesces and skips the excess. The test that expected exactly one callback could therefore fail on a busy machine. It now drains the callbacks of the write and then requires silence, which still fails for a poller that does not update its baseline.

…failure is reported

The reloader test wrote a file with a new failure while the automatic retries were running and
expected the next retry to report it. The write is ordinary, not atomic, so a retry can read the
file while it is empty or half written. An empty document is valid, so such a retry succeeds and
ends the retries, and the new failure is never read; a half-written file is reported as a failure
of its own. The test now loads the final content on demand and inspects the reports as a whole,
and a fixture helper collects the callbacks that arrive within a settle period.

…y extension

Applications and editors rewrite data files in place: they truncate the file
and then write the new content. With pyyaml installed, a load in between parsed
the empty file as a document with no entries, whatever its name.

The parser is now chosen by the file name: a name ending in .yaml or .yml is
YAML, and any other file is JSON. Files must be UTF-8. An empty JSON file, and
JSON that is not an object such as null, fail to parse; YAML that is empty,
only comments, or null has no entries.

The Reloader holds back a file whose content is in effect and that a load finds
with no entries, until it has stayed so, unwritten, for the retry delay. The
delay is measured from the file's own read and starts over when the file's
modification time or size changes. Each file is held for at most five retry
delays from its first hold, and its bound starts over only at a load that
holds nothing back. A load reads and classifies every file, even after a
failure, and fails with the first failure; content, even content that cannot
be parsed, or a missing file ends the empty state. The skip-unchanged digest
covers each path, whether its file exists, and its bytes.

Tests rewrite files in place through ldclient/testing/file_util.py and time
the hold on an injected clock.

An entry's own key was kept when it differed from its map key. The entry was stored under one key and reported by evaluations under the other, and two entries with the same key under different map keys were two items with one key. The map key is now the entry's key for every purpose.

…tched

A link whose target's directory did not exist when the links were resolved, at start or after the directory was deleted, was not resolved again until another change was reported, so edits to its target after the directory appeared were missed. Such a link, or a target directory that cannot be watched, now keeps the retry schedule running, which resolves the links again, and the callback runs once when a retry watches a target. A relative link is now joined to the real path of the directory that holds it, which a test pins for a link in a directory reached through another link.

…atched directory, and warn once for an unwatchable directory

Two threads that resolved the links at once could both find a target's directory unwatched; the observer shares one watch per directory, so the thread that lost the race removed the watch the other had stored, and the target was never watched again. That watch is now kept. A retry that resolved a link to a target in a directory that was already watched set up no watch and so signaled no change; it now signals whenever a link leads to a new target. The retry logged a warning for a directory that cannot be watched yet on every attempt; it now warns once per directory and reason and logs repeats at debug level until the directory is watched. The watcher docstring now names the changes that watching does not follow, a link further along the chain or a configured directory that is pointed elsewhere or replaced, and points such deployments to polling.

…ectory's warning only where the loss is reported

Windows needs to know that a link leads to a directory when the link is created, so the watcher tests now say so for their directory links. The race test reads the target directory's key from the watcher instead of computing it, since Windows resolves the path differently. The loss of a watched directory is reported through inotify, so the part of the warning test that loses the directory runs on Linux only.